#ifndef _MUTEX_HPP__
#define _MUTEX_HPP__
#include <pthread.h>
#include <string>
#include <functional>
#include <sys/types.h>
#include <unistd.h>
// v2
namespace ThreadMoudle
{


class Mutex
{

    /*
    互斥锁的核心是 “唯一的同步状态” 和 “独占的资源管理”，拷贝操作会破坏这两点：
    - 拷贝导致多个对象共享同一把锁，破坏同步语义；
    - 拷贝导致资源重复释放，引发内存错误。
    如果需要转移互斥锁的所有权（如在容器中存储 Mutex），可以允许移动构造（通过转移指针所有权，避免资源冲突）：
    */
    Mutex(const Mutex& m) = delete;
    const Mutex& operator=(const Mutex& m)= delete;

public:
    Mutex()
    :_mutex_ptr(new pthread_mutex_t)
    {
        pthread_mutex_init(_mutex_ptr,nullptr);
    }

    void Lock()
    {
        pthread_mutex_lock(_mutex_ptr);
    }

    void Unlock()
    {
        pthread_mutex_unlock(_mutex_ptr);
    }
    pthread_mutex_t* Mutex_ptr()
    {
        return _mutex_ptr;
    }

    ~Mutex()
    {
        pthread_mutex_destroy(_mutex_ptr);
        delete _mutex_ptr;
    }

private:
    pthread_mutex_t* _mutex_ptr;

};

class LockGuard
{
public:
    void Lock()
    {
        _mtx_ptr->Lock();
    }
    void Unlock()
    {
        _mtx_ptr->Unlock();
    }
    LockGuard(Mutex* mtx_ptr)
    :_mtx_ptr(mtx_ptr)
    {
        Lock();
    }
    LockGuard(Mutex& mtx)
    :_mtx_ptr(&mtx)
    {
        Lock();
    }


    ~LockGuard()
    {
        Unlock();
    }

    

private:
    Mutex* _mtx_ptr;
};




}

#endif